# 是否允许开启自我保护模式，缺省：true
# 当Eureka服务器在短时间内丢失过多客户端时，自我保护模式可使服务端不再删除失去连接的客户端
eureka.server.enable-self-preservation = false
 
# Peer节点更新间隔，单位：毫秒
eureka.server.peer-eureka-nodes-update-interval-ms = 
 
# Eureka服务器清理无效节点的时间间隔，单位：毫秒，缺省：60000，即60秒
eureka.server.eviction-interval-timer-in-ms = 60000
复制

# 服务名，默认取 spring.application.name 配置值，如果没有则为 unknown
eureka.instance.appname = eureka-client
 
# 实例ID
eureka.instance.instance-id = eureka-client-instance1
 
# 应用实例主机名
eureka.instance.hostname = localhost
 
# 客户端在注册时使用自己的IP而不是主机名，缺省：false
eureka.instance.prefer-ip-address = false
 
# 应用实例IP
eureka.instance.ip-address = 127.0.0.1
 
# 服务失效时间，失效的服务将被剔除。单位：秒，默认：90
eureka.instance.lease-expiration-duration-in-seconds = 90
 
# 服务续约（心跳）频率，单位：秒，缺省30
eureka.instance.lease-renewal-interval-in-seconds = 30
 
# 状态页面的URL，相对路径，默认使用 HTTP 访问，如需使用 HTTPS则要使用绝对路径配置，缺省：/info
eureka.instance.status-page-url-path = /info
 
# 健康检查页面的URL，相对路径，默认使用 HTTP 访问，如需使用 HTTPS则要使用绝对路径配置，缺省：/health
eureka.instance.health-check-url-path = /health
复制

# Eureka服务器的地址，类型为HashMap，缺省的Key为 defaultZone；缺省的Value为 http://localhost:8761/eureka
# 如果服务注册中心为高可用集群时，多个注册中心地址以逗号分隔。 
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka
 
# 是否向注册中心注册自己，缺省：true
# 一般情况下，Eureka服务端是不需要再注册自己的
eureka.client.register-with-eureka = true
 
# 是否从Eureka获取注册信息，缺省：true
# 一般情况下，Eureka服务端是不需要的
eureka.client.fetch-registry = true
 
# 客户端拉取服务注册信息间隔，单位：秒，缺省：30
eureka.client.registry-fetch-interval-seconds = 30
 
# 是否启用客户端健康检查
eureka.client.health-check.enabled = true
 
# 获取集群中最新的server节点数据频率  单位：秒 缺省：5min
eureka.client.eureka-service-url-poll-interval-seconds = 60
 
# 连接Eureka服务器的超时时间，单位：秒，缺省：5
eureka.client.eureka-server-connect-timeout-seconds = 5
 
# 从Eureka服务器读取信息的超时时间，单位：秒，缺省：8
eureka.client.eureka-server-read-timeout-seconds = 8
 
# 获取实例时是否只保留状态为 UP 的实例，缺省：true
eureka.client.filter-only-up-instances = true
 
# Eureka服务端连接空闲时的关闭时间，单位：秒，缺省：30
eureka.client.eureka-connection-idle-timeout-seconds = 30
 
# 从Eureka客户端到所有Eureka服务端的连接总数，缺省：200
eureka.client.eureka-server-total-connections = 200
 
# 从Eureka客户端到每个Eureka服务主机的连接总数，缺省：50
eureka.client.eureka-server-total-connections-per-host = 50
复制

  client:
    service-url:
      defaultZone: http://192.168.12.3:8761/eureka,http://192.168.14.4:8761/eureka
    register-with-eureka: true
复制

# 全局配置
ribbon:
  ConnectTimeout: 1000 #服务请求连接超时时间（毫秒）
  ReadTimeout: 3000 #服务请求处理超时时间（毫秒）
  OkToRetryOnAllOperations: true #对超时请求启用重试机制
  MaxAutoRetriesNextServer: 1 #切换重试实例的最大个数
  MaxAutoRetries: 1 # 切换实例后重试最大次数
  NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #修改负载均衡算法
# 局部配置
user-service:
  ribbon:
复制

  spring:
  	cloud:
   	  loadbalancer:
     	 retry:
        	enable: true
复制

public class CustomLoadBalancerConfiguration {
    //实例选择器配置
    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(ConfigurableApplicationContext context){
        return ServiceInstanceListSupplier.builder()
                //使用服务发现
                .withDiscoveryClient()
                //使用健康检查
                .withHealthChecks()
                //···
                .build(context);
    }
}
复制

spring:
  cloud:
    loadbalancer:
      clients:
        my-service:
复制

public class CustomLoadBalancerConfiguration {

    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(loadBalancerClientFactory
                .getLazyProvider(name, ServiceInstanceListSupplier.class),
                name);
    }
}
复制

@Configuration
//value的值指定了在给定的loadbalancer client配置下，要发送请求到哪个服务(服务名)
@LoadBalancerClient(value = "stores", configuration = CustomLoadBalancerConfiguration.class)
public class MyConfiguration {
    @Bean
    @LoadBalanced
    public WebClient.Builder loadBalancedWebClientBuilder() {
        return WebClient.builder();
    }
}
//配置多个
//@LoadBalancerClients({
//    @LoadBalancerClient(value = "stores", configuration = StoresLoadBalancerClientConfiguration.class),
//    @LoadBalancerClient(value = "customers", configuration = CustomersLoadBalancerClientConfiguration.class)
//})
复制

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.DefaultResponse;
import org.springframework.cloud.client.loadbalancer.EmptyResponse;
import org.springframework.cloud.client.loadbalancer.Request;
import org.springframework.cloud.client.loadbalancer.Response;
import reactor.core.publisher.Mono;

public class RandomLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    private static final Log log = LogFactory.getLog(RandomLoadBalancer.class);
    private final String serviceId;
    private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;

    public RandomLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId) {
        this.serviceId = serviceId;
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
    }

    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServiceInstanceListSupplier supplier = (ServiceInstanceListSupplier)this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
        return supplier.get(request).next().map((serviceInstances) -> {
            return this.processInstanceResponse(supplier, serviceInstances);
        });
    }

    private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier, List<ServiceInstance> serviceInstances) {
        Response<ServiceInstance> serviceInstanceResponse = this.getInstanceResponse(serviceInstances);
        if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {
            ((SelectedInstanceCallback)supplier).selectedServiceInstance((ServiceInstance)serviceInstanceResponse.getServer());
        }

        return serviceInstanceResponse;
    }

    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {
        if (instances.isEmpty()) {
            if (log.isWarnEnabled()) {
                log.warn("No servers available for service: " + this.serviceId);
            }

            return new EmptyResponse();
        } else { //此处实现自己的负载均衡策略
            int index = ThreadLocalRandom.current().nextInt(instances.size());
            ServiceInstance instance = (ServiceInstance)instances.get(index);
            return new DefaultResponse(instance);
        }
    }
}

复制

	@Bean
    @LoadBalanced
    public WebClient.Builder loadBalancedWebClientBuilder() {
        return WebClient.builder();
    }
	@Bean
	@LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
复制

spring:
  cloud:
    loadbalancer:
      health-check:
#       创建延迟
        initial-delay: 10s
#       检查间隔
        interval: 100s
#       健康检查使用的url
        path:
          default: /actuator/health
          service-a: /health
          service-b: /health
#       健康检查使用的端口，未指定则为服务实例上的可用端口
        port: 8081
#       服务列表的刷新一般由代理实现，例如服务发现。如果不想使用代理来刷新服务列表，可以使用以下配置使服务列表的刷新由HealthCheckServiceInstanceListSupplier操作。
#       开启刷新服务列表
        refetch-instances: true
#       设置刷新间隔
        refetch-instances-interval: 100s
#       取消额外的健康检查(每个服务实例的刷新也会触发一次健康检查)
        repeat-health-check: false
复制

<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
复制

# 消费者可不注册进Eureka
eureka:
  client:
    register-with-eureka: false
#   Eureka服务端地址
    service-url:
      defaultZone: http://127.0.0.1:8001/eureka,http://localhost:8002/eureka
复制

@Service
//  上下文标识,服务提供者的微服务应用名
@FeignClient(contextId = "service-name",value = "spring-application-name")
public interface TestService {
//  服务提供者的服务调用地址
    @GetMapping("/provider/test/{id}", headers = {"Content-Type=application/json;charset=UTF-8",···})
    Object testService(@PathVariable("id") Long id);
}
复制

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
复制

spring: # rabbitmq配置
  rabbitmq:
    host: 
    port: 
    username: 
    password: 
management:
  endpoints:
    web:
      exposure:
        include: "busrefresh" # 暴露/actuator/busrefresh端点
复制

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
复制

spring: # rabbitmq配置
  rabbitmq:
    host: 
    port: 
    username: 
    password: 
复制

spring:  
  application:  
    name: stream-provider  
  cloud:  
    stream:  
      binders: #要绑定的rabbitmq服务信息  
        rabbit: #自定义的Binder名称  
          type: rabbit #binder类型  
          environment: #环境配置  
            spring:  
              rabbitmq:  
                host: wolf.bj.cn  
                port: 5672  
                username: admin  
                password: 8a57gw72uri  
      bindings: # 服务整合处理  
        output: # 自定义通道名称  
          destination: Exchange #消息目标的交换机名  
          content-type: application/json #消息类型(json)  
          binder: rabbit #指定该通道使用的binder  
        output2: # 自定义通道名称  
          destination: Exchange2 #消息目标的交换机名  
          content-type: text/plain #消息类型(文本)  
          binder: rabbit #指定该通道使用的binder
复制